ടൈപ്പ്സ്ക്രിപ്റ്റ് ടെംപ്ലേറ്റ് ലിറ്ററൽ വാലിഡേഷൻ എഞ്ചിൻ: റൺടൈം സ്ട്രിംഗ് വെരിഫിക്കേഷൻ

ടൈപ്പ്സ്ക്രിപ്റ്റിന്റെ ടെംപ്ലേറ്റ് ലിറ്ററൽ ടൈപ്പുകൾ കംപൈൽ-ടൈമിൽ ശക്തമായ സ്ട്രിംഗ് മാനിപുലേഷനും ടൈപ്പ് സുരക്ഷയും നൽകുന്നു. എന്നിരുന്നാലും, ഈ പരിശോധനകൾ കംപൈൽ-ടൈമിൽ പരിമിതമാണ്. ഈ ബ്ലോഗ് പോസ്റ്റ് ടൈപ്പ്സ്ക്രിപ്റ്റ് ടെംപ്ലേറ്റ് ലിറ്ററൽ ടൈപ്പുകൾക്കായി ഒരു റൺടൈം വാലിഡേഷൻ എഞ്ചിൻ എങ്ങനെ നിർമ്മിക്കാമെന്ന് വിശദീകരിക്കുന്നു, ഇത് പ്രോഗ്രാം എക്സിക്യൂഷൻ സമയത്ത് ശക്തമായ സ്ട്രിംഗ് വെരിഫിക്കേഷനും സാധ്യമായ പിശകുകൾ തടയാനും സഹായിക്കുന്നു.

ടൈപ്പ്സ്ക്രിപ്റ്റ് ടെംപ്ലേറ്റ് ലിറ്ററൽ ടൈപ്പുകളിലേക്കുള്ള ഒരു ആമുഖം

ലിറ്ററൽ വാല്യൂകൾ, യൂണിയനുകൾ, ടൈപ്പ് ഇൻഫറൻസ് എന്നിവയെ അടിസ്ഥാനമാക്കി നിർദ്ദിഷ്‌ട സ്ട്രിംഗ് രൂപങ്ങൾ നിർവചിക്കാൻ ടെംപ്ലേറ്റ് ലിറ്ററൽ ടൈപ്പുകൾ നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് കൃത്യമായ ടൈപ്പ് ചെക്കിംഗും ഓട്ടോ-കംപ്ലീഷനും സാധ്യമാക്കുന്നു, പ്രത്യേകിച്ചും സ്ട്രക്ച്ചേർഡ് ഡാറ്റയുമായോ ഡൊമെയ്ൻ-സ്പെസിഫിക് ഭാഷകളുമായോ പ്രവർത്തിക്കുമ്പോൾ ഇത് വളരെ ഉപയോഗപ്രദമാണ്.

ഉദാഹരണത്തിന്, കറൻസി കോഡുകളെ പ്രതിനിധീകരിക്കുന്ന ഒരു ടൈപ്പ് പരിഗണിക്കുക:

            
type CurrencyCode = "USD" | "EUR" | "GBP";

type FormattedCurrencyString = `${CurrencyCode}-${number}`;

const validCurrency: FormattedCurrencyString = "USD-100"; // OK
const invalidCurrency: FormattedCurrencyString = "CAD-50"; // Type error at compile time

            

              
                Copy
              
            
          

ഈ ഉദാഹരണം, കംപൈൽ-ടൈമിൽ ടൈപ്പ്സ്ക്രിപ്റ്റ് എങ്ങനെ FormattedCurrencyString ടൈപ്പ് നടപ്പിലാക്കുന്നുവെന്ന് കാണിക്കുന്നു. എന്നിരുന്നാലും, കറൻസി കോഡ് ഒരു ബാഹ്യ ഉറവിടത്തിൽ നിന്നാണ് വരുന്നതെങ്കിൽ (ഉദാഹരണത്തിന്, ഉപയോക്താവിന്റെ ഇൻപുട്ട്, API പ്രതികരണം), ടൈപ്പ് സുരക്ഷ ഉറപ്പാക്കാൻ നിങ്ങൾക്ക് റൺടൈം വാലിഡേഷൻ ആവശ്യമാണ്.

റൺടൈം വാലിഡേഷൻ്റെ ആവശ്യകത

ടൈപ്പ്സ്ക്രിപ്റ്റ് മികച്ച കംപൈൽ-ടൈം ടൈപ്പ് ചെക്കിംഗ് നൽകുമ്പോൾ, റൺടൈമിൽ ബാഹ്യ ഉറവിടങ്ങളിൽ നിന്ന് ലഭിക്കുന്ന ഡാറ്റയുടെ സാധുത ഉറപ്പ് നൽകാൻ അതിന് കഴിയില്ല. കംപൈൽ-ടൈം ടൈപ്പുകളെ മാത്രം ആശ്രയിക്കുന്നത് അപ്രതീക്ഷിത പിശകുകളിലേക്കും സുരക്ഷാ പ്രശ്നങ്ങളിലേക്കും നയിച്ചേക്കാം.

ഇനിപ്പറയുന്ന സാഹചര്യം പരിഗണിക്കുക:

            
function processCurrency(currencyString: FormattedCurrencyString) {
  // ... some logic that assumes the string is correctly formatted
}

const userInput = "CAD-50"; // Assume this comes from user input

// This will compile, but will cause a runtime error if the logic inside
// `processCurrency` relies on the format.
processCurrency(userInput as FormattedCurrencyString);

            

              
                Copy
              
            
          

ഈ സാഹചര്യത്തിൽ, നമ്മൾ userInput-നെ FormattedCurrencyString ആയി കാസ്റ്റ് ചെയ്യുകയാണ്, ഇത് ടൈപ്പ്സ്ക്രിപ്റ്റിന്റെ കംപൈൽ-ടൈം പരിശോധനകളെ മറികടക്കുന്നു. processCurrency ഫംഗ്ഷൻ സ്ട്രിംഗ് ശരിയായി ഫോർമാറ്റ് ചെയ്തിട്ടുണ്ടെന്ന് അനുമാനിച്ച് പ്രവർത്തിക്കുകയാണെങ്കിൽ, ഒരു റൺടൈം പിശക് സംഭവിക്കും.

റൺടൈം വാലിഡേഷൻ, റൺടൈമിൽ ലഭിക്കുന്ന ഡാറ്റ പ്രതീക്ഷിക്കുന്ന ടൈപ്പ്സ്ക്രിപ്റ്റ് ടൈപ്പുകൾക്ക് അനുസൃതമാണോ എന്ന് പരിശോധിക്കുന്നതിലൂടെ ഈ വിടവ് നികത്തുന്നു.

ഒരു ടെംപ്ലേറ്റ് ലിറ്ററൽ വാലിഡേഷൻ എഞ്ചിൻ നിർമ്മിക്കുന്നു

റെഗുലർ എക്സ്പ്രഷനുകളും ടൈപ്പ്സ്ക്രിപ്റ്റിന്റെ ടൈപ്പ് സിസ്റ്റവും ഉപയോഗിച്ച് നമുക്ക് ഒരു റൺടൈം വാലിഡേഷൻ എഞ്ചിൻ നിർമ്മിക്കാൻ കഴിയും. ഈ എഞ്ചിൻ ഒരു ടെംപ്ലേറ്റ് ലിറ്ററൽ ടൈപ്പും ഒരു സ്ട്രിംഗും ഇൻപുട്ടായി എടുക്കുകയും സ്ട്രിംഗ് ടൈപ്പുമായി പൊരുത്തപ്പെടുന്നുണ്ടോ എന്ന് നൽകുകയും ചെയ്യും.

ഘട്ടം 1: റൺടൈം വാലിഡേഷനായി ഒരു ടൈപ്പ് നിർവചിക്കുന്നു

ആദ്യം, ഒരു ടെംപ്ലേറ്റ് ലിറ്ററൽ ടൈപ്പിന്റെ റൺടൈം തുല്യതയെ പ്രതിനിധീകരിക്കാൻ കഴിയുന്ന ഒരു ജനറിക് ടൈപ്പ് നമുക്ക് ആവശ്യമാണ്. ഈ ടൈപ്പിന് ലിറ്ററലുകൾ, യൂണിയനുകൾ, ടൈപ്പ് പാരാമീറ്ററുകൾ എന്നിവയുൾപ്പെടെ വിവിധതരം ടെംപ്ലേറ്റ് ലിറ്ററലുകൾ കൈകാര്യം ചെയ്യാൻ കഴിയണം.

            
type TemplateLiteralToRegex = 
  T extends `${infer Start}${infer Middle}${infer End}`
    ? Start extends string
      ? Middle extends string
        ? End extends string
          ? TemplateLiteralToRegexStart & TemplateLiteralToRegexMiddle & TemplateLiteralToRegex
          : never
        : never
      : never
    : TemplateLiteralToRegexStart;


type TemplateLiteralToRegexStart = T extends `${infer Literal}` ? Literal : string;

type TemplateLiteralToRegexMiddle = T extends `${infer Literal}` ? Literal : string;

            

              
                Copy
              
            
          

ഈ റിക്കേഴ്സീവ് ടൈപ്പ് നിർവചനം ടെംപ്ലേറ്റ് ലിറ്ററലിനെ അതിന്റെ ഘടകഭാഗങ്ങളായി വിഭജിക്കുകയും ഓരോ ഭാഗത്തെയും ഒരു റെഗുലർ എക്സ്പ്രഷൻ പാറ്റേണിലേക്ക് പരിവർത്തനം ചെയ്യുകയും ചെയ്യുന്നു.

ഘട്ടം 2: വാലിഡേഷൻ ഫംഗ്ഷൻ നടപ്പിലാക്കുന്നു

അടുത്തതായി, ടെംപ്ലേറ്റ് ലിറ്ററൽ ടൈപ്പും സാധൂകരിക്കേണ്ട സ്ട്രിംഗും ഇൻപുട്ടായി എടുക്കുന്ന വാലിഡേഷൻ ഫംഗ്ഷൻ നമ്മൾ നടപ്പിലാക്കുന്നു. ഈ ഫംഗ്ഷൻ TemplateLiteralToRegex ഉപയോഗിച്ച് ജനറേറ്റുചെയ്ത റെഗുലർ എക്സ്പ്രഷൻ ഉപയോഗിച്ച് സ്ട്രിംഗ് പരിശോധിക്കുന്നു.

            
function isValid(str: string, templateType: T): boolean {
  const regexPattern = `^${convertTemplateLiteralToRegex(templateType)}$`;
  const regex = new RegExp(regexPattern);
  return regex.test(str);
}

function convertTemplateLiteralToRegex(templateType: T): string {
  // Basic conversion for literal strings - extend this for more complex scenarios
  return templateType.replace(/[.*+?^${}()|\[\]]/g, '\\$&'); // Escape special regex characters
}

            

              
                Copy
              
            
          

ഈ ഫംഗ്ഷൻ പ്രത്യേക റെഗുലർ എക്സ്പ്രഷൻ ക്യാരക്ടറുകളെ എസ്കേപ്പ് ചെയ്യുകയും ടെംപ്ലേറ്റ് ലിറ്ററൽ ടൈപ്പിൽ നിന്ന് ഒരു റെഗുലർ എക്സ്പ്രഷൻ ഉണ്ടാക്കുകയും, തുടർന്ന് ആ റെഗുലർ എക്സ്പ്രഷനുമായി സ്ട്രിംഗിനെ താരതമ്യം ചെയ്യുകയും ചെയ്യുന്നു.

ഘട്ടം 3: വാലിഡേഷൻ എഞ്ചിൻ ഉപയോഗിക്കുന്നു

ഇപ്പോൾ, റൺടൈമിൽ നിങ്ങളുടെ ടെംപ്ലേറ്റ് ലിറ്ററൽ ടൈപ്പുകൾക്കെതിരെ സ്ട്രിംഗുകൾ സാധൂകരിക്കുന്നതിന് നിങ്ങൾക്ക് isValid ഫംഗ്ഷൻ ഉപയോഗിക്കാം.

            
type CurrencyCode = "USD" | "EUR" | "GBP";

type FormattedCurrencyString = `${CurrencyCode}-${number}`;

const userInput1 = "USD-100";
const userInput2 = "CAD-50";

console.log(`'${userInput1}' is valid: ${isValid(userInput1, "USD-100" )}`); // true
console.log(`'${userInput2}' is valid: ${isValid(userInput2, "USD-100")}`); // false

console.log(`'${userInput1}' is valid: ${isValid(userInput1, `USD-${100}`)}`); // true
console.log(`'${userInput2}' is valid: ${isValid(userInput2, `USD-${100}`)}`); // false


            

              
                Copy
              
            
          

ഈ ഉദാഹരണം, FormattedCurrencyString ടൈപ്പിനെതിരെ ഉപയോക്തൃ ഇൻപുട്ട് സാധൂകരിക്കുന്നതിന് isValid ഫംഗ്ഷൻ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് കാണിക്കുന്നു. നൽകിയിട്ടുള്ള ടെംപ്ലേറ്റ് ലിറ്ററലിനെ അടിസ്ഥാനമാക്കി ഇൻപുട്ട് സ്ട്രിംഗുകൾ സാധുവാണോ അല്ലയോ എന്ന് ഔട്ട്പുട്ട് കാണിക്കും.

അഡ്വാൻസ്ഡ് വാലിഡേഷൻ സാഹചര്യങ്ങൾ

യൂണിയനുകൾ, കണ്ടീഷണൽ ടൈപ്പുകൾ, റിക്കേഴ്സീവ് ടൈപ്പുകൾ പോലുള്ള കൂടുതൽ സങ്കീർണ്ണമായ സാഹചര്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനായി അടിസ്ഥാന വാലിഡേഷൻ എഞ്ചിൻ വികസിപ്പിക്കാവുന്നതാണ്.

യൂണിയനുകൾ കൈകാര്യം ചെയ്യുന്നു

യൂണിയനുകൾ കൈകാര്യം ചെയ്യുന്നതിന്, യൂണിയനിലെ ഏതെങ്കിലും അംഗവുമായി പൊരുത്തപ്പെടുന്ന ഒരു റെഗുലർ എക്സ്പ്രഷൻ ജനറേറ്റുചെയ്യുന്നതിനായി നിങ്ങൾക്ക് TemplateLiteralToRegex ടൈപ്പ് പരിഷ്കരിക്കാവുന്നതാണ്.

            
type CurrencyCode = "USD" | "EUR" | "GBP";

type FormattedCurrencyString = `${CurrencyCode}-${number}`;

function isValidCurrencyCode(str: string, templateType: T): boolean {
    const currencyCodes: CurrencyCode[] = ["USD", "EUR", "GBP"];
    return currencyCodes.includes(str as CurrencyCode);
}


function isValidUnionFormattedCurrencyString(str: string): boolean {
    const parts = str.split('-');
    if(parts.length !== 2) return false;
    const [currencyCode, amount] = parts;

    if (!isValidCurrencyCode(currencyCode, currencyCode)) return false;

    if (isNaN(Number(amount))) return false;

    return true;
}

console.log(`'USD-100' is valid formatted string: ${isValidUnionFormattedCurrencyString('USD-100')}`);
console.log(`'CAD-50' is valid formatted string: ${isValidUnionFormattedCurrencyString('CAD-50')}`);


            

              
                Copy
              
            
          

കണ്ടീഷണൽ ടൈപ്പുകൾ കൈകാര്യം ചെയ്യുന്നു

റൺടൈമിൽ കണ്ടീഷൻ വിലയിരുത്തുകയും ഫലത്തെ അടിസ്ഥാനമാക്കി വ്യത്യസ്ത റെഗുലർ എക്സ്പ്രഷനുകൾ ജനറേറ്റുചെയ്യുകയും ചെയ്തുകൊണ്ട് കണ്ടീഷണൽ ടൈപ്പുകൾ കൈകാര്യം ചെയ്യാൻ കഴിയും.

            
type IsString = T extends string ? true : false;

// This example requires more advanced logic and isn't fully implementable using simple regex.
// Runtime type guards offer a more robust solution in this specific scenario.
// The below code is illustrative and would need adaptation to handle complex conditional types.

function isString(value: any): value is string {
    return typeof value === 'string';
}

function isValidConditionalType(value: any): boolean {
    return isString(value);
}

console.log(`'hello' is a string: ${isValidConditionalType('hello')}`);
console.log(`123 is a string: ${isValidConditionalType(123)}`);

            

              
                Copy
              
            
          

റിക്കേഴ്സീവ് ടൈപ്പുകൾ കൈകാര്യം ചെയ്യുന്നു

റെഗുലർ എക്സ്പ്രഷൻ പാറ്റേൺ ജനറേറ്റുചെയ്യുന്ന ഒരു റിക്കേഴ്സീവ് ഫംഗ്ഷൻ നിർവചിച്ചുകൊണ്ട് റിക്കേഴ്സീവ് ടൈപ്പുകൾ കൈകാര്യം ചെയ്യാൻ കഴിയും. എന്നിരുന്നാലും, ഇൻഫിനിറ്റ് റിക്കർഷനും സ്റ്റാക്ക് ഓവർഫ്ലോ പിശകുകളും ഒഴിവാക്കാൻ ശ്രദ്ധിക്കുക. ആഴത്തിലുള്ള റിക്കർഷനുകൾക്ക്, ഉചിതമായ പരിധികളുള്ള ഇറ്ററേറ്റീവ് സമീപനങ്ങൾ അത്യാവശ്യമാണ്.

റെഗുലർ എക്സ്പ്രഷനുകൾക്കുള്ള ബദലുകൾ

സ്ട്രിംഗ് വാലിഡേഷന് റെഗുലർ എക്സ്പ്രഷനുകൾ ശക്തമായ ഒരു ടൂൾ ആണെങ്കിലും, അവ സങ്കീർണ്ണവും പരിപാലിക്കാൻ പ്രയാസമുള്ളതുമാകാം. റൺടൈം വാലിഡേഷനുള്ള മറ്റ് സമീപനങ്ങളിൽ ഇവ ഉൾപ്പെടുന്നു:

• കസ്റ്റം വാലിഡേഷൻ ഫംഗ്ഷനുകൾ: നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ ആവശ്യകതകളെ അടിസ്ഥാനമാക്കി നിർദ്ദിഷ്‌ട ടൈപ്പുകൾ സാധൂകരിക്കുന്നതിന് കസ്റ്റം ഫംഗ്ഷനുകൾ എഴുതുക.
• ടൈപ്പ് ഗാർഡുകൾ: റൺടൈമിൽ ഒരു വേരിയബിളിന്റെ ടൈപ്പ് ചുരുക്കുന്നതിന് ടൈപ്പ് ഗാർഡുകൾ ഉപയോഗിക്കുക.
• വാലിഡേഷൻ ലൈബ്രറികൾ: Zod അല്ലെങ്കിൽ Yup പോലുള്ള നിലവിലുള്ള വാലിഡേഷൻ ലൈബ്രറികൾ ഉപയോഗിച്ച് വാലിഡേഷൻ പ്രക്രിയ ലളിതമാക്കുക.

ഉദാഹരണത്തിന്, Zod, ഒരു സ്കീമ-അധിഷ്ഠിത പ്രഖ്യാപനം നൽകുന്നു, അത് ഒരു വാലിഡേഷൻ റൺടൈമിലേക്ക് വിവർത്തനം ചെയ്യുന്നു:

            
import { z } from 'zod';

const CurrencyCodeSchema = z.enum(['USD', 'EUR', 'GBP']);
const FormattedCurrencyStringSchema = z.string().regex(new RegExp(`^${CurrencyCodeSchema.enum.USD}|${CurrencyCodeSchema.enum.EUR}|${CurrencyCodeSchema.enum.GBP}-[0-9]+$`));

try {
  const validCurrency = FormattedCurrencyStringSchema.parse("USD-100");
  console.log("Valid Currency:", validCurrency);
} catch (error) {
  console.error("Invalid Currency:", error);
}

try {
    const invalidCurrency = FormattedCurrencyStringSchema.parse("CAD-50");
    console.log("Valid Currency:", invalidCurrency); //This won't execute if parse fails.
  } catch (error) {
    console.error("Invalid Currency:", error);
  }


            

              
                Copy
              
            
          

റൺടൈം വാലിഡേഷനായുള്ള മികച്ച രീതികൾ

റൺടൈം വാലിഡേഷൻ നടപ്പിലാക്കുമ്പോൾ, ഇനിപ്പറയുന്ന മികച്ച രീതികൾ മനസ്സിൽ വയ്ക്കുക:

• അതിർത്തിയിൽ സാധൂകരിക്കുക: ഡാറ്റ നിങ്ങളുടെ സിസ്റ്റത്തിലേക്ക് പ്രവേശിക്കുമ്പോൾ തന്നെ സാധൂകരിക്കുക (ഉദാഹരണത്തിന്, ഉപയോക്തൃ ഇൻപുട്ട്, API പ്രതികരണങ്ങൾ).
• വ്യക്തമായ പിശക് സന്ദേശങ്ങൾ നൽകുക: ഉപയോക്താക്കൾക്ക് അവരുടെ ഇൻപുട്ട് എന്തുകൊണ്ട് അസാധുവാണെന്ന് മനസ്സിലാക്കാൻ സഹായിക്കുന്നതിന് വിവരദായകമായ പിശക് സന്ദേശങ്ങൾ നൽകുക.
• സ്ഥിരമായ ഒരു വാലിഡേഷൻ തന്ത്രം ഉപയോഗിക്കുക: ഡാറ്റയുടെ സമഗ്രത ഉറപ്പാക്കാൻ നിങ്ങളുടെ ആപ്ലിക്കേഷനിലുടനീളം സ്ഥിരമായ ഒരു വാലിഡേഷൻ തന്ത്രം സ്വീകരിക്കുക.
• നിങ്ങളുടെ വാലിഡേഷൻ ലോജിക് പരീക്ഷിക്കുക: സാധുവായതും അസാധുവായതുമായ ഡാറ്റ ശരിയായി തിരിച്ചറിയുന്നുവെന്ന് ഉറപ്പാക്കാൻ നിങ്ങളുടെ വാലിഡേഷൻ ലോജിക് സമഗ്രമായി പരീക്ഷിക്കുക.
• പ്രകടനവും സുരക്ഷയും സന്തുലിതമാക്കുക: സുരക്ഷാ ഭീഷണികളെ ഫലപ്രദമായി തടയുന്നുവെന്ന് ഉറപ്പാക്കുന്നതിനൊപ്പം പ്രകടനത്തിനായി നിങ്ങളുടെ വാലിഡേഷൻ ലോജിക് ഒപ്റ്റിമൈസ് ചെയ്യുക. ഡനയൽ ഓഫ് സർവീസിലേക്ക് നയിക്കുന്ന അമിത സങ്കീർണ്ണമായ റെജെക്സ് ഒഴിവാക്കുക.

അന്താരാഷ്ട്രവൽക്കരണ പരിഗണനകൾ

ഒരു ആഗോള പശ്ചാത്തലത്തിൽ സ്ട്രിംഗ് വാലിഡേഷൻ കൈകാര്യം ചെയ്യുമ്പോൾ, നിങ്ങൾ അന്താരാഷ്ട്രവൽക്കരണം (i18n), പ്രാദേശികവൽക്കരണം (l10n) എന്നിവ പരിഗണിക്കേണ്ടതുണ്ട്. തീയതികൾ, നമ്പറുകൾ, കറൻസി മൂല്യങ്ങൾ പോലുള്ള സ്ട്രിംഗുകൾ ഫോർമാറ്റ് ചെയ്യുന്നതിന് വ്യത്യസ്ത ലൊക്കേലുകൾക്ക് വ്യത്യസ്ത നിയമങ്ങളുണ്ടാകാം.

ഉദാഹരണത്തിന്, യൂറോയുടെ കറൻസി ചിഹ്നം (€) ലൊക്കേലിനെ ആശ്രയിച്ച് തുകയ്ക്ക് മുമ്പോ ശേഷമോ ദൃശ്യമാകാം. അതുപോലെ, ദശാംശ വിഭജനം ഒരു പിരീഡ് (.) അല്ലെങ്കിൽ ഒരു കോമ (,) ആകാം.

ഈ വ്യതിയാനങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് Intl പോലുള്ള അന്താരാഷ്ട്രവൽക്കരണ ലൈബ്രറികൾ ഉപയോഗിക്കാം, ഇത് ലൊക്കേൽ-സെൻസിറ്റീവ് ഡാറ്റ ഫോർമാറ്റ് ചെയ്യുന്നതിനും പാഴ്സ് ചെയ്യുന്നതിനും API-കൾ നൽകുന്നു. ഉദാഹരണത്തിന്, വ്യത്യസ്ത കറൻസി ഫോർമാറ്റുകൾ കൈകാര്യം ചെയ്യുന്നതിന് മുമ്പത്തെ ഉദാഹരണം നിങ്ങൾക്ക് പരിഷ്കരിക്കാവുന്നതാണ്:

            
function isValidCurrencyString(currencyString: string, locale: string): boolean {
  try {
    const formatter = new Intl.NumberFormat(locale, { style: 'currency', currency: currencyString.substring(0,3) }); //Very basic example

    //Attempt to parse the currency using formatter. This example is intentionally very simple.
    return true;
  } catch (error) {
    return false;
  }
}

console.log(`USD-100 is valid for en-US: ${isValidCurrencyString('USD-100', 'en-US')}`);
console.log(`EUR-100 is valid for fr-FR: ${isValidCurrencyString('EUR-100', 'fr-FR')}`);

            

              
                Copy
              
            
          

ഈ കോഡ് സ്നിപ്പെറ്റ് ഒരു അടിസ്ഥാന ഉദാഹരണം നൽകുന്നു. ശരിയായ അന്താരാഷ്ട്രവൽക്കരണത്തിന് കൂടുതൽ സമഗ്രമായ കൈകാര്യം ചെയ്യൽ ആവശ്യമാണ്, ഒരുപക്ഷേ വ്യത്യസ്ത ലൊക്കേലുകളിലുടനീളം കറൻസി ഫോർമാറ്റിംഗിനും വാലിഡേഷനും വേണ്ടി പ്രത്യേകം രൂപകൽപ്പന ചെയ്ത ബാഹ്യ ലൈബ്രറികളോ API-കളോ ഉപയോഗിക്കേണ്ടി വന്നേക്കാം.

ഉപസംഹാരം

ദൃഢവും വിശ്വസനീയവുമായ ടൈപ്പ്സ്ക്രിപ്റ്റ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിന്റെ ഒരു പ്രധാന ഭാഗമാണ് റൺടൈം വാലിഡേഷൻ. ടൈപ്പ്സ്ക്രിപ്റ്റിന്റെ ടെംപ്ലേറ്റ് ലിറ്ററൽ ടൈപ്പുകളെ റെഗുലർ എക്സ്പ്രഷനുകളോ മറ്റ് വാലിഡേഷൻ രീതികളോ ഉപയോഗിച്ച് സംയോജിപ്പിക്കുന്നതിലൂടെ, റൺടൈമിൽ സ്ട്രിംഗുകളുടെ സാധുത പരിശോധിക്കുന്നതിന് നിങ്ങൾക്ക് ശക്തമായ ഒരു എഞ്ചിൻ സൃഷ്ടിക്കാൻ കഴിയും.

ഈ സമീപനം ടൈപ്പ് സുരക്ഷ വർദ്ധിപ്പിക്കുന്നു, അപ്രതീക്ഷിത പിശകുകൾ തടയുന്നു, കൂടാതെ നിങ്ങളുടെ കോഡിന്റെ മൊത്തത്തിലുള്ള ഗുണനിലവാരം മെച്ചപ്പെടുത്തുന്നു. നിങ്ങൾ കൂടുതൽ സങ്കീർണ്ണമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുമ്പോൾ, നിങ്ങളുടെ ഡാറ്റ പ്രതീക്ഷിക്കുന്ന ടൈപ്പുകൾക്കും ഫോർമാറ്റുകൾക്കും അനുസൃതമാണെന്ന് ഉറപ്പാക്കാൻ റൺടൈം വാലിഡേഷൻ ഉൾപ്പെടുത്തുന്നത് പരിഗണിക്കുക.

കൂടുതൽ പഠനത്തിനായി

• കൂടുതൽ സങ്കീർണ്ണമായ വാലിഡേഷൻ സാഹചര്യങ്ങൾക്കായി വിപുലമായ റെഗുലർ എക്സ്പ്രഷൻ ടെക്നിക്കുകൾ പര്യവേക്ഷണം ചെയ്യുക.
• സ്കീമ-അധിഷ്ഠിത വാലിഡേഷനായി Zod, Yup പോലുള്ള വാലിഡേഷൻ ലൈബ്രറികളെക്കുറിച്ച് അന്വേഷിക്കുക.
• ടൈപ്പ്സ്ക്രിപ്റ്റ് ടൈപ്പുകളിൽ നിന്ന് യാന്ത്രികമായി വാലിഡേഷൻ ഫംഗ്ഷനുകൾ ജനറേറ്റുചെയ്യുന്നതിന് കോഡ് ജനറേഷൻ ടെക്നിക്കുകൾ ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക.
• ലൊക്കേൽ-സെൻസിറ്റീവ് ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിനായി അന്താരാഷ്ട്രവൽക്കരണ ലൈബ്രറികളും API-കളും പഠിക്കുക.